/**
 *
 * @returns 返回今天字符串 2024-01-02
 */
export function getTodayDate(): string {
  const today: Date = new Date();
  const year: number = today.getFullYear();
  const month: number = today.getMonth() + 1;
  const day: number = today.getDate();

  // 将月份和日期补零
  const formattedMonth: string = month < 10 ? `0${month}` : `${month}`;
  const formattedDay: string = day < 10 ? `0${day}` : `${day}`;

  // 返回格式化后的日期字符串
  return `${year}-${formattedMonth}-${formattedDay}`;
}

/**
 * 输入时间戳转换日期
 * @param timestamp
 * @returns
 */
export function formatDateFromTimestamp(timestamp: number): string {
  const date: Date = new Date(timestamp);
  const year: number = date.getFullYear();
  const month: number = date.getMonth() + 1;
  const day: number = date.getDate();

  // 将月份和日期补零
  const formattedMonth: string = month < 10 ? `0${month}` : `${month}`;
  const formattedDay: string = day < 10 ? `0${day}` : `${day}`;

  // 返回格式化后的日期字符串
  return `${year}-${formattedMonth}-${formattedDay}`;
}

/**
 * 返回今天字符串 2024-01-02 00:00
 * @param date 时间类型
 * @returns 2024-01-02 00:00
 */
export function formatDate(date: Date) {
  const yyyy = date.getFullYear();
  const mm = String(date.getMonth() + 1).padStart(2, '0');
  const dd = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  return `${yyyy}-${mm}-${dd} ${hours}:${minutes}`;
}

/**
 * 判断当整数大于12位时候自动转换成字符串形式
 * @param data 数据类型
 * @returns
 */
export function stringifyNumbers(data: any[]): any[] {
  function stringify(obj: any) {
    for (const key in obj) {
      if (typeof obj[key] === 'number' && obj[key].toString().length > 12) {
        obj[key] = BigInt(obj[key]).toString();
      } else if (typeof obj[key] === 'object') {
        stringify(obj[key]);
      }
    }
  }
  data.forEach((item) => stringify(item));
  return data;
}

/**
 * 创建的表格转换成可以提交的表格类型
 * @param data
 * @returns
 */
export function transformData(data: any): any[] {
  return data.map((item: any) => {
    // 创建一个新的对象，用于存储转换后的数据
    const newItem = {
      // 在此处保持与原始对象相同的属性，并进行适当的修改或保留
      cameraRecognition: 0,
      componentId: item.componentId,
      componentType: item.componentType,
      componentValue: '',
      defaultValue: item.defaultValue || '', // 如果原始对象中没有 defaultValue 属性，则设为 ""
      formMainId: item.formMainId,
      formName: item.formName || '', // 如果原始对象中没有 formName 属性，则设为 ""
      imgUseAlbumEnable: false,
      isNa: false,
      isNaValue: false,
      isRed: false,
      isValidate: item.isValidate,
      isValidationStatistics: false,
      mId: 0,
      optionId: 0,
      optionTitle: '',
      options: [],
      prompt: item.prompt || '', // 如果原始对象中没有 prompt 属性，则设为 ""
      selected: false,
      textType: 0,
      title: item.title || '', // 如果原始对象中没有 title 属性，则设为 ""
      validationExpression: '',
    };
    // 如果原始对象中存在 options 属性并且有选项数组，则进行转换
    if (item.options && item.options.length > 0) {
      newItem.options = item.options.map((option: any) =>
        // count++,
        ({
          // 在此处保持与原始选项对象相同的属性，并进行适当的修改或保留
          cameraRecognition: 0,
          componentId: newItem.componentId,
          componentType: option.componentType,
          componentValue: '',
          defaultValue: option.defaultValue || '',
          formMainId: option.formMainId,
          formName: option.formName || '',
          imgUseAlbumEnable: false,
          isDefault: option.isDefault || false,
          isNa: false,
          isNaValue: false,
          isRed: false,
          isValidate: option.isValidate,
          isValidationStatistics: false,
          mId: 0,
          optionId: option.optionId, //(BigInt(option.optionId) + BigInt(count)).toString(),
          optionTitle: option.optionTitle || '',
          prompt: option.prompt || '',
          selected: option.selected || false,
          textType: 0,
          title: option.title || '',
          validationExpression: '',
        }),
      );
    }
    return newItem; // 返回转换后的对象
  });
}

/**
 * 分割名称
 * @param item 字符串
 * @returns 返回简体中文
 */
export const splitName = (item: string) => {
  const matchResult = item.split('$');
  return matchResult ? matchResult[0] : ''; // 如果匹配成功返回匹配的第一个结果，否则返回空字符串
};
/**
 * 计算开始时间跟结束使劲按
 * @param startTime 开始时间
 * @param endTime 结束时间
 * @returns
 */
export function subtractTime(startTime: string, endTime: string): number {
  function timeToMinutes(time: string): number {
    const [hours, minutes] = time.split(':').map(Number);
    return hours * 60 + minutes;
  }
  const startMinutes = timeToMinutes(startTime);
  const endMinutes = timeToMinutes(endTime);
  return endMinutes - startMinutes;
}

/**
 * 用于图片数组转换成字符串
 * @param arrayToString
 * @returns
 */
export function convertToString(
  arrayToString: { url: string; extname: string; name: string }[],
): string {
  if (arrayToString.length === 1) {
    return arrayToString[0].url;
  } else {
    return arrayToString.map((item) => item.url).join(',');
  }
}

/**
 * 用于字符串转换成图片数组
 * @param stringToArrays
 * @returns
 */
export function convertToArray(
  stringToArrays: string,
): { url: string; extname: string; name: string }[] {
  const urls = stringToArrays.split(',');

  const arrayToString = urls.map((url) => ({
    url,
    extname: 'jpg',
    name: url.split('/').pop() || url, // 默认值为url
  }));
  return arrayToString;
}

/**
 * 用于将数组分组
 * @param stringToArray
 * @returns
 */
export function groupArrayAndLastItem(
  arr: any[],
  groupSize: number = 5,
): [any[], any[]] {
  const result: any[] = [];
  let i = 0;

  while (i < arr.length - 5) {
    result.push(arr.slice(i, i + groupSize));
    i += groupSize;
  }

  const lastArray = arr.slice(i); // 剩余的元素单独作为一个数组
  return [result, lastArray];
}

/**
 * 用于对比加载数据赋值操作
 * @param newData 新数据
 * @param  configData 配置数据
 * @returns
 */
export function compareLoadData(newData: any, configData: Partial<any>): any {
  for (const key in configData) {
    if (configData.hasOwnProperty(key) && newData.hasOwnProperty(key)) {
      newData[key] = configData[key];
    }
  }
  return newData;
}

/**
 * 取冰箱随机数 0-4°C
 * @returns
 */
export function random0_4(): number {
  return Math.floor(Math.random() * 5);
}

/**
 * 取冰箱随机数 15-22
 * @returns
 */
export function random15_22(): number {
  return Math.floor(Math.random() * 8) + 15;
}
/**
 *  随机一个传入一个数，然后进行+1或者-1操作
 * @param num
 * @returns
 */
export function randomPlusOrMinus(num: number): number {
  const randomNum = Math.floor(Math.random() * 2) * 2 - 1;
  return num + randomNum;
}

/**
 * 随机生成0-0.9之间的小数,取一位小数
 * @returns
 */
export function random0_09(): number {
  return Math.floor(Math.random() * 10) / 10;
}
